package com.framework.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.context.ContextLoaderListener;

import com.framework.dao.IbatisDao;
import com.framework.model.IData;
import com.framework.model.IDataModel;

public abstract class IbatisService implements IIbatisService
{

    public String sqlMapNameSpace;

    @Autowired
    public IbatisDao daoIbatis;

    public abstract void setSqlMapNameSpace();
    
    public IbatisService() {
    	this.setSqlMapNameSpace();
	}

    public void setDaoIbatis(IbatisDao daoIbatis)
    {
        this.daoIbatis = daoIbatis;
    }
    

    public IbatisDao getDaoIbatis() {
    	if(daoIbatis==null){
    		daoIbatis= (IbatisDao)ContextLoaderListener.getCurrentWebApplicationContext().getBean("daoIbatis");
    	}
		return daoIbatis;
	}
    
    /*
     * 以下9个函数是Service的默认实现,一般情况下,你可以直接使用他们 public Object getObjectInfo( Object );
     * public List getObjectList(Object ); public Object insertObject(Object );
     * public int insertObjectAndGetID(Object ); public int updateObject(Object );
     * public int deleteObject(Object ); public boolean checkObjectExists(Object );
     * public int getRecordCount(Object ); public List getPageObjectList(Object*
     * ,int , int );
     */

    /**
     * 根据conditionObjInfo对象中的条件，从数据库中取得对对象。
     * 这是一个默认的实现，必须对应statementId为getObjectInfo
     */
    public Object getObjectInfo(Object conditionObj)
    {
        return getDaoIbatis().getObjectInfo(sqlMapNameSpace, conditionObj);
    }

    
    /**
     * 根据conditionObjInfo对象中的条件，从数据库中取得多个对象。
     * 这是一个默认的实现，必须对应statementId为getObjectList
     */
    @SuppressWarnings("unchecked")
	public List getObjectList(Object conditionObj)
    {
        return getDaoIbatis().getObjectList(sqlMapNameSpace, conditionObj);
    }
    

    /**
     * 向数据库中插入一条记录，数据被封装在info对象中。 这是一个默认的实现，必须对应statementId为insertObject
     */
    public Object insertObject(Object objInfo)
    {
        return getDaoIbatis().insertObject(sqlMapNameSpace, objInfo);
    }

    /**
     * 向数据库中插入一条记录并返回刚插入的ID，数据被封装在info对象中。
     * 这是一个默认的实现，必须对应statementId为insertObjectAndGetID
     */
    public int insertObjectAndGetID(Object objInfo)
    {
        return getDaoIbatis().insertObjectAndGetID(sqlMapNameSpace, objInfo);
    }

    /**
     * 更新数据库中的记录 这是一个默认的实现，必须对应statementId为updateObject
     */
    public int updateObject(Object objInfo)
    {
        return getDaoIbatis().updateObject(sqlMapNameSpace, objInfo);
    }

    /**
     * 删除数据库中的记录 这是一个默认的实现，必须对应statementId为deleteObject
     */
    public int deleteObject(Object conditionObj)
    {
        return getDaoIbatis().deleteObject(sqlMapNameSpace, conditionObj);
    }

    

    
    /**
     * 检查数据库中是否已经存在此记录，若存在返回true;否则，返回false。
     * 这是一个默认的实现，必须对应statementId为checkObjectExists
     */
    public boolean checkObjectExists(Object conditionObj)
    {
        return getDaoIbatis().checkObjectExists(sqlMapNameSpace, conditionObj);
    }

    /**
     * getPageObjectList(String,Object,int,int);根据conditionObjInfo条件从数据库中取出从intStart开始起的intOffset条记录集
     * 这是一个默认的实现，必须对应statementId为getObjectPageList,同时必须配合getRecordCount(String ,
     * Object)使用
     * 
     * getRecordCount(String , Object)实现从数据库中取得对象的个数也可独立使用。
     * 这是一个默认的实现，必须对应statementId为getRecordCount
     */
    public int getRecordCount(Object conditionObj)
    {
        return getDaoIbatis().getRecordCount(sqlMapNameSpace, conditionObj);
    }

    @SuppressWarnings("unchecked")
	public List getPageObjectList(IData conditionObj, int intStart,
            int intOffset)
    {
    	if(intStart>0){
    		intStart=(intStart-1)*intOffset;
    	}
        return getDaoIbatis().getPageObjectList(sqlMapNameSpace, conditionObj,
                intStart, intOffset);
    }
    
    
    @SuppressWarnings("unchecked")
	public List getPageObjectList(IDataModel dataModel, int intStart,
            int intOffset)
    {
    	if(intStart>0){
    		intStart=(intStart-1)*intOffset;
    	}
        return getDaoIbatis().getPageObjectList(sqlMapNameSpace, dataModel,
                intStart, intOffset);
    }
    
    

    /*
     * 以下9个函数是Service提供的自定义实现,你可以使用你自己的statmentId完成不同的操作 public Object
     * getObjectInfo(String , String , Object ); public List
     * getObjectList(String , String , Object ); public Object
     * insertObject(String , String , Object ); public int
     * insertObjectAndGetID(String , String , Object ); public int
     * updateObject(String , String , Object ); public int deleteObject(String
     * ,String , Object ); public boolean checkObjectExists(String , String
     * ,Object ); public int getRecordCount(String , String , Object ); public
     * List getPageObjectList(String , String , Object ,int , int );
     */

    /**
     * 根据conditionObjInfo对象中的条件，从数据库中取得对对象。 这是一个自定义的实现，你可以使用你自己设定的statementId
     */
    public Object getObjectInfo(String statementId, Object conditionObj)
    {
        return getDaoIbatis().getObjectInfo(sqlMapNameSpace, statementId,
                conditionObj);
    }

    
    public Object getObjectInfo(String sqlMapNameSpace,String statementId, Object conditionObj)
    {
        return getDaoIbatis().getObjectInfo(sqlMapNameSpace, statementId,
                conditionObj);
    }
    
    /**
     * 根据conditionObjInfo对象中的条件，从数据库中取得多个对象。 这是一个自定义的实现，你可以使用你自己设定的statementId
     */
    @SuppressWarnings("unchecked")
	public List getObjectList(String statementId, Object conditionObj)
    {
        return getDaoIbatis().getObjectList(sqlMapNameSpace, statementId,conditionObj);
    }

    public List getObjectList(String sqlMapName,String statementId, Object conditionObj)
    {
        return getDaoIbatis().getObjectList(sqlMapName, statementId,conditionObj);
    }
    
    /**
     * 向数据库中插入一条记录，数据被封装在info对象中。 这是一个自定义的实现，你可以使用你自己设定的statementId
     */
    public Object insertObject(String statementId, Object objInfo)
    {
        return getDaoIbatis().insertObject(sqlMapNameSpace, statementId, objInfo);
    }

    
    public Object insertObject(String sqlMapNameSpace,String statementId, Object objInfo)
    {
        return getDaoIbatis().insertObject(sqlMapNameSpace, statementId, objInfo);
    }
    
    /**
     * 向数据库中插入一条记录并返回刚插入的ID，数据被封装在info对象中。 这是一个自定义的实现，你可以使用你自己设定的statementId
     */
    public int insertObjectAndGetID(String statementId, Object objInfo)
    {
        return getDaoIbatis().insertObjectAndGetID(sqlMapNameSpace, statementId,
                objInfo);
    }

    /**
     * 更新数据库中的记录 这是一个自定义的实现，你可以使用你自己设定的statementId
     */
    public int updateObject(String statementId, Object objInfo)
    {
        return getDaoIbatis().updateObject(sqlMapNameSpace, statementId, objInfo);
    }

    /**
     * 删除数据库中的记录 这是一个自定义的实现，你可以使用你自己设定的statementId
     */
    public int deleteObject(String statementId, Object conditionObj)
    {
        return getDaoIbatis().deleteObject(sqlMapNameSpace, statementId, conditionObj);
    }

    
    public int deleteObject(String sqlMapNameSpace,String statementId, Object conditionObj)
    {
        return getDaoIbatis().deleteObject(sqlMapNameSpace, statementId, conditionObj);
    }

    /**
     * 检查数据库中是否已经存在此记录，若存在返回true;否则，返回false。 这是一个自定义的实现，你可以使用你自己设定的statementId
     */
    public boolean checkObjectExists(String statementId, Object conditionObj)
    {
        return getDaoIbatis().checkObjectExists(sqlMapNameSpace, statementId,conditionObj);
    }


}